﻿using System;
using System.CodeDom.Compiler;
using System.Diagnostics;

namespace Teal.Compiler {

    /// <summary>
    /// 表示一个已解析的表达式。
    /// </summary>
    public abstract partial class ResolvedExpression : Expression {

        /// <summary>
        /// 获取当前节点的开始位置。
        /// </summary>
        public override Location startLocation {
            get {
                return new Location();
            }
            set {
                throw new Unreachable();
            }
        }

        /// <summary>
        /// 获取当前节点的结束位置。
        /// </summary>
        public override Location endLocation {
            get {
                return new Location();
            }
            set {
                throw new Unreachable();
            }
        }

        /// <summary>
        /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
        /// </summary>
        /// <param name="writer">写入的目标对象。</param>
        public override void write(IndentedTextWriter writer) {
            writer.Write("\"<已优化的表达式>\"");
        }

        ///// <summary>
        ///// 将当前表达式作为值解析。
        ///// </summary>
        ///// <param name="context">包含所有解析状态的上下文对象。</param>
        ///// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null 。</returns>
        //public override Expression resolveAsValue(ResolveContext context) {
        //    throw new Unreachable();
        //}

    }

    /// <summary>
    /// 表示一个已解析的代表类型转换操作的表达式。
    /// </summary>
    public partial class ResolvedConversionExpression : ResolvedExpression {

        /// <summary>
        /// 获取当前转换之前的值。
        /// </summary>
        public Expression value;

        /// <summary>
        /// 获取或设置当前转换的目标类型。
        /// </summary>
        public TypeReference targetType;

        /// <summary>
        /// 获取是否忽略运行时转换错误。
        /// </summary>
        public bool ignoreRuntimeError;

        /// <summary>
        /// 获取当前转换的类型。
        /// </summary>
        public ConversionType conversion;

        /// <summary>
        /// 获取当前表达式解析后的返回值类型。
        /// </summary>
        public override TypeReference resolvedType {
            get {
                return targetType;
            }
        }

        /// <summary>
        /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
        /// </summary>
        /// <param name="writer">写入的目标对象。</param>
        public override void write(IndentedTextWriter writer) {
            writer.Write("(");
            if (ignoreRuntimeError) {
                value.write(writer);
                writer.Write(" as ");
                writer.Write(targetType.signature);
            } else {
                writer.Write("(");
                writer.Write(targetType.signature);
                writer.Write(")");
                value.write(writer);
            }
            writer.Write(")");
        }

    }

    ///// <summary>
    ///// 表示编译器动态成员的表达式。
    ///// </summary>
    //sealed partial class CompilerGeneratedExpression : Expression {

    //    /// <summary>
    //    /// 获取实际的计算表达式。
    //    /// </summary>
    //    public Expression body;

    //    /// <summary>
    //    /// 获取当前节点的起始位置。
    //    /// </summary>
    //    public override Location startLocation {
    //        get {
    //            return body.startLocation;
    //        }
    //        set {
    //            body.startLocation = value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前节点的结束位置。
    //    /// </summary>
    //    public override Location endLocation {
    //        get {
    //            return body.endLocation;
    //        }
    //        set {
    //            body.endLocation = value;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点的内容写入指定的输出器。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        body.write(writer);
    //    }

    //    /// <summary>
    //    /// 报告当前节点不可访问的警告。
    //    /// </summary>
    //    /// <returns>如果已输出警告信息则返回 true，否则返回 false。</returns>
    //    public override bool reportUnreachableCodeWarning() {
    //        return body.reportUnreachableCodeWarning();
    //    }

    //    /// <summary>
    //    /// 将当前表达式解析为成员引用。
    //    /// </summary>
    //    /// <param name="currentMemberDefinition">当前表达式所在的成员定义。</param>
    //    /// <param name="memberUsage">当前成员的使用场景。</param>
    //    /// <returns>返回一个成员引用表达式。如果解析失败则返回 null。</returns>
    //    public override MemberReference resolveAsMember(MemberDefinition currentMemberDefinition, MemberUsage memberUsage) {
    //        return body.resolveAsMember(currentMemberDefinition, memberUsage);
    //    }

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return body.resolvedType;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前表达式作为值解析，然后隐式转换为指定的类型，同时允许更新 var 的含义。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="declareType">声明的类型。如果需要则更新声明类型。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context) {
    //        return body;
    //    }

    //    /// <summary>
    //    /// 将当前表达式作为指定类型的值解析。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="expectedType">期待的返回类型。如果表达式未返回此类型，则尝试进行转换。</param>
    //    /// <param name="explicitCast">指示强制转换为目标类型的方式。</param>
    //    /// <returns>返回解析后的新表达式，它的所有子表达式都已经被解析。如果解析出现错误则返回 null。</returns>
    //    public override Expression resolveAsValue(ResolveContext context, TypeReference expectedType, State explicitCast) {
    //        return body;
    //    }

    //    /// <summary>
    //    /// 将当前表达式解析为一个符号。
    //    /// </summary>
    //    /// <param name="context">用于存储所有解析信息的上下文对象。</param>
    //    /// <param name="symbolUsage">当前符号的使用场景。</param>
    //    /// <param name="instance">返回当前符号的所属实例对象。</param>
    //    /// <returns>返回解析后的符号对象。如果解析出现错误则返回 null。</returns>
    //    public override ISymbol resolveAsSymbol(ResolveContext context, SymbolUsage symbolUsage, out Expression instance) {
    //        instance = null;
    //        return body;
    //    }

    //    /// <summary>
    //    /// 获取当前表达式到指定类型的转换类型。
    //    /// </summary>
    //    /// <param name="targetType">要转换的目标类型。</param>
    //    /// <returns>获取转换方式。</returns>
    //    public override ConversionType classifyConversion(TypeReference targetType) {
    //        return body.classifyConversion(targetType);
    //    }

    //}

    #region SymbolExpressions

    ///// <summary>
    ///// 表示一个已解析的代表存储操作的表达式。
    ///// </summary>
    //public abstract partial class ResolvedStoreExpression : ResolvedExpression {

    //    /// <summary>
    //    /// 获取要设置的值。
    //    /// </summary>
    //    public Expression value;

    //    /// <summary>
    //    /// 标记当前赋值语句是否需要返回值。
    //    /// </summary>
    //    public bool returnVoid;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return returnVoid ? PredefinedTypes.@void : value.resolvedType;
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个已解析的代表 this 求址的表达式。
    ///// </summary>
    //public partial class ResolvedAddressOfThisExpression : ResolvedExpression {

    //    /// <summary>
    //    /// 获取当前要载入的变量。
    //    /// </summary>
    //    public ThisLiteral target;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Ptr_T.makeGenericType(target.resolvedType);
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write("(&this)");
    //    }

    //}

    //#region 变量

    ///// <summary>
    ///// 表示一个已解析的代表载入变量值的表达式。
    ///// </summary>
    //public partial class ResolvedLoadVariableExpression : ResolvedExpression {

    //    /// <summary>
    //    /// 获取当前要载入的变量。
    //    /// </summary>
    //    public Variable target;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return target.resolvedType;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(target.name);
    //    }

    //}

    ///// <summary>
    ///// 表示一个已解析的代表存储变量值的表达式。
    ///// </summary>
    //public partial class ResolvedStoreVariableExpression : ResolvedStoreExpression {

    //    /// <summary>
    //    /// 获取当前要载入的变量。
    //    /// </summary>
    //    public Variable target;

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        if (!returnVoid) {
    //            writer.Write('(');
    //        }
    //        writer.Write(target.name);
    //        writer.Write(" = ");
    //        value.write(writer);
    //        if (!returnVoid) {
    //            writer.Write(')');
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个已解析的代表变量求址的表达式。
    ///// </summary>
    //public partial class ResolvedAddressOfVariableExpression : ResolvedExpression {

    //    /// <summary>
    //    /// 获取当前要载入的变量。
    //    /// </summary>
    //    public Variable target;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Ptr_T.makeGenericType(target.resolvedType);
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write("(&");
    //        writer.Write(target.name);
    //        writer.Write(")");
    //    }

    //}

    //#endregion

    //#region 参数

    ///// <summary>
    ///// 表示一个已解析的代表载入参数值的表达式。
    ///// </summary>
    //public partial class ResolvedLoadParameterExpression : ResolvedExpression {

    //    /// <summary>
    //    /// 获取当前要载入的参数。
    //    /// </summary>
    //    public Parameter target;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return target.resolvedType;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(target.name);
    //    }

    //}

    ///// <summary>
    ///// 表示一个已解析的代表存储参数值的表达式。
    ///// </summary>
    //public partial class ResolvedStoreParameterExpression : ResolvedStoreExpression {

    //    /// <summary>
    //    /// 获取当前要载入的参数。
    //    /// </summary>
    //    public Parameter target;

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        if (!returnVoid) {
    //            writer.Write('(');
    //        }
    //        writer.Write(target.name);
    //        writer.Write(" = ");
    //        value.write(writer);
    //        if (!returnVoid) {
    //            writer.Write(')');
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个已解析的代表参数求址的表达式。
    ///// </summary>
    //public partial class ResolvedAddressOfParameterExpression : ResolvedExpression {

    //    /// <summary>
    //    /// 获取当前要载入的变量。
    //    /// </summary>
    //    public Parameter target;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Ptr_T.makeGenericType(target.resolvedType);
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write("(&");
    //        writer.Write(target.name);
    //        writer.Write(")");
    //    }

    //}

    //#endregion

    //#region 字段

    ///// <summary>
    ///// 表示一个已解析的代表载入字段值的表达式。
    ///// </summary>
    //public partial class ResolvedLoadFieldExpression : ResolvedExpression {

    //    /// <summary>
    //    /// 获取当前操作的实例对象。
    //    /// </summary>
    //    public Expression instance;

    //    /// <summary>
    //    /// 获取当前要载入的字段。
    //    /// </summary>
    //    public FieldReference target;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return target.returnType;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        if (target.modifiers.hasFlag(Modifiers.@static)) {
    //            writer.Write(target.fullName);
    //        } else {
    //            instance.write(writer);
    //            writer.Write('.');
    //            writer.Write(target.name);
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个已解析的代表存储字段值的表达式。
    ///// </summary>
    //public partial class ResolvedStoreFieldExpression : ResolvedStoreExpression {

    //    /// <summary>
    //    /// 获取当前操作的实例对象。
    //    /// </summary>
    //    public Expression instance;

    //    /// <summary>
    //    /// 获取当前要载入的变量。
    //    /// </summary>
    //    public FieldReference target;

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        if (!returnVoid) {
    //            writer.Write('(');
    //        }
    //        if (target.modifiers.hasFlag(Modifiers.@static)) {
    //            writer.Write(target.fullName);
    //        } else {
    //            instance.write(writer);
    //            writer.Write('.');
    //            writer.Write(target.name);
    //        }
    //        writer.Write(" = ");
    //        value.write(writer);
    //        if (!returnVoid) {
    //            writer.Write(')');
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个已解析的代表字段求址的表达式。
    ///// </summary>
    //public partial class ResolvedAddressOfFieldExpression : ResolvedExpression {

    //    /// <summary>
    //    /// 获取当前操作的实例对象。
    //    /// </summary>
    //    public Expression instance;

    //    /// <summary>
    //    /// 获取当前要载入的变量。
    //    /// </summary>
    //    public FieldReference target;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Ptr_T.makeGenericType(target.returnType);
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write("(&");
    //        if (target.modifiers.hasFlag(Modifiers.@static)) {
    //            writer.Write(target.fullName);
    //        } else {
    //            instance.write(writer);
    //            writer.Write('.');
    //            writer.Write(target.name);
    //        }
    //        writer.Write(')');
    //    }

    //}

    //#endregion

    //#region 属性

    ///// <summary>
    ///// 表示一个已解析的代表载入属性值的表达式。
    ///// </summary>
    //public partial class ResolvedLoadPropertyExpression : ResolvedExpression {

    //    /// <summary>
    //    /// 获取当前操作的实例对象。
    //    /// </summary>
    //    public Expression instance;

    //    /// <summary>
    //    /// 获取当前要载入的字段。
    //    /// </summary>
    //    public PropertyReference target;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return target.returnType;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        if (target.modifiers.hasFlag(Modifiers.@static)) {
    //            writer.Write(target.fullName);
    //        } else {
    //            instance.write(writer);
    //            writer.Write('.');
    //            writer.Write(target.name);
    //        }
    //    }

    //}

    ///// <summary>
    ///// 表示一个已解析的代表存储属性值的表达式。
    ///// </summary>
    //public partial class ResolvedStorePropertyExpression : ResolvedStoreExpression {

    //    /// <summary>
    //    /// 获取当前操作的实例对象。
    //    /// </summary>
    //    public Expression instance;

    //    /// <summary>
    //    /// 获取当前要载入的变量。
    //    /// </summary>
    //    public PropertyReference target;

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        if (!returnVoid) {
    //            writer.Write('(');
    //        }
    //        if (target.modifiers.hasFlag(Modifiers.@static)) {
    //            writer.Write(target.fullName);
    //        } else {
    //            instance.write(writer);
    //            writer.Write('.');
    //            writer.Write(target.name);
    //        }
    //        writer.Write(" = ");
    //        value.write(writer);
    //        if (!returnVoid) {
    //            writer.Write(')');
    //        }
    //    }

    //}

    //#endregion

    #region 方法

    /// <summary>
    /// 表示一个已解析的代表载入方法的表达式。
    /// </summary>
    public partial class ResolvedMethodReferenceExpression : ResolvedExpression {

        /// <summary>
        /// 获取使用的实例对象。
        /// </summary>
        public Expression instance;

        /// <summary>
        /// 获取调用的方法引用。
        /// </summary>
        public MethodReference target;

        /// <summary>
        /// 获取或设置当前表达式的类型。
        /// </summary>
        public TypeReference type;

        /// <summary>
        /// 获取当前表达式解析后的返回值类型。
        /// </summary>
        public override TypeReference resolvedType {
            get {
                return type;
            }
        }

        /// <summary>
        /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
        /// </summary>
        /// <param name="writer">写入的目标对象。</param>
        public override void write(IndentedTextWriter writer) {
            if (target.modifiers.hasFlag(Modifiers.@static)) {
                writer.Write(target.signature);
            } else {
                instance.write(writer);
                writer.Write('.');
                writer.Write(target.name);
            }
        }

    }

    /// <summary>
    /// 表示一个已解析的代表载入方法组的表达式。
    /// </summary>
    public partial class ResolvedMethodReferenceGroupExpression : ResolvedExpression {

        /// <summary>
        /// 获取使用的实例对象。
        /// </summary>
        public Expression instance;

        /// <summary>
        /// 获取调用的方法引用。
        /// </summary>
        public MemberReferenceGroup target;

        /// <summary>
        /// 获取或设置当前表达式的类型。
        /// </summary>
        public TypeReference type;

        /// <summary>
        /// 获取当前表达式解析后的返回值类型。
        /// </summary>
        public override TypeReference resolvedType {
            get {
                return type;
            }
        }

        //public override Expression resolveAsValue(ResolveContext context, TypeReference expectedType, State explicitCast = State.unset) {
        //    return base.resolveAsValue(context, expectedType, explicitCast);
        //}

        /// <summary>
        /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
        /// </summary>
        /// <param name="writer">写入的目标对象。</param>
        public override void write(IndentedTextWriter writer) {
            if (target[0].modifiers.hasFlag(Modifiers.@static)) {
                writer.Write(target[0].signature);
            } else {
                instance.write(writer);
                writer.Write('.');
                writer.Write(target[0].name);
            }
        }

    }

    /// <summary>
    /// 表示一个已解析的代表方法引用调用的表达式。
    /// </summary>
    public partial class ResolvedMethodInvocationExpression : ResolvedExpression {

        /// <summary>
        /// 获取使用的实例对象。
        /// </summary>
        public Expression instance;

        /// <summary>
        /// 获取调用的方法引用。
        /// </summary>
        public MemberReference target;

        /// <summary>
        /// 获取当前调用的函数参数。
        /// </summary>
        public Expression[] arguments;

        /// <summary>
        /// 获取当前表达式解析后的返回值类型。
        /// </summary>
        public override TypeReference resolvedType {
            get {
                if (target is MethodReference) {
                    return ((MethodReference)target).returnType;
                }
                if (target is PropertyReference) {
                    return ((PropertyReference)target).returnType;
                }
                throw new Unreachable();
            }
        }

        /// <summary>
        /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
        /// </summary>
        /// <param name="writer">写入的目标对象。</param>
        public override void write(IndentedTextWriter writer) {
            if (target.modifiers.hasFlag(Modifiers.@static)) {
                writer.Write(target.signature);
            } else {
                instance.write(writer);
                writer.Write('.');
                writer.Write(target.name);
            }
            writer.Write('(');
            if (arguments != null) {
                for (int i = 0; i < arguments.Length; i++) {
                    if (i > 0) {
                        writer.Write(", ");
                    }
                    arguments[i].write(writer);
                }
            }
            writer.Write(')');
        }

    }

    /// <summary>
    /// 表示一个已解析的代表函数表达式调用的表达式。
    /// </summary>
    public partial class ResolvedFunctionInvocationExpression : ResolvedExpression {

        /// <summary>
        /// 获取调用的方法引用。
        /// </summary>
        public Expression target;

        /// <summary>
        /// 获取当前调用的函数参数。
        /// </summary>
        public Expression[] arguments;

        /// <summary>
        /// 获取当前表达式解析后的返回值类型。
        /// </summary>
        public override TypeReference resolvedType {
            get {
                Debug.Assert(target.resolvedType.genericDefinitionType == PredefinedTypes.System_Func_T);
                return target.resolvedType.genericArguments[0];
            }
        }

        /// <summary>
        /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
        /// </summary>
        /// <param name="writer">写入的目标对象。</param>
        public override void write(IndentedTextWriter writer) {
            writer.Write('(');
            target.write(writer);
        }

    }

    /// <summary>
    /// 表示一个对象创建的表达式。
    /// </summary>
    public partial class ObjectCreationExpression : ResolvedExpression {

        /// <summary>
        /// 获取调用的方法引用。
        /// </summary>
        public TypeReference target;

        /// <summary>
        /// 获取当前调用的函数参数。
        /// </summary>
        public ResolvedMethodInvocationExpression constructorInvocation;

        /// <summary>
        /// 获取当前表达式解析后的返回值类型。
        /// </summary>
        public override TypeReference resolvedType {
            get {
                return target;
            }
        }

        /// <summary>
        /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
        /// </summary>
        /// <param name="writer">写入的目标对象。</param>
        public override void write(IndentedTextWriter writer) {
            writer.Write("new ");
            writer.Write(target.signature);
            writer.Write('(');
            if (constructorInvocation.arguments != null) {
                for (int i = 0; i < constructorInvocation.arguments.Length; i++) {
                    if (i > 0) {
                        writer.Write(", ");
                    }
                    constructorInvocation.arguments[i].write(writer);
                }
            }
            writer.Write(')');
        }

    }

    #endregion

    #endregion

    //#region Constants

    ///// <summary>
    ///// 表示一个常量。
    ///// </summary>
    //public abstract partial class Constant : ResolvedExpression {

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public abstract Constant calc(TokenType @operator);

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public abstract Constant calc(TokenType @operator, Constant value);

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public abstract int int32Value { get; }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public abstract uint uint32Value { get; }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public abstract long int64Value { get; }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public abstract ulong uint64Value { get; }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public abstract float float32Value { get; }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public abstract double float64Value { get; }

    //}

    ///// <summary>
    ///// 表示一个 8 位整数、16 位整数或字符常量。
    ///// </summary>
    //public sealed partial class SmallIntConstant : Constant {

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    int _value;

    //    TypeReference _type;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return _type;
    //        }
    //    }

    //    public SmallIntConstant(TypeReference type, int value) {
    //        _type = type;
    //        _value = value;
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        throw new Unreachable();
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        throw new Unreachable();
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        SmallIntConstant val = other as SmallIntConstant;
    //        return val != null && _type == val._type && _value == val._value;
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return _value.GetHashCode();
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            return _value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            return (uint)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            return (long)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            return (ulong)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            return (float)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            return (double)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(_value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个 32 位有符整数常量。
    ///// </summary>
    //public sealed partial class Int32Constant : Constant {

    //    /// <summary>
    //    /// 当前常量的值。
    //    /// </summary>
    //    int _value;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Int32;
    //        }
    //    }

    //    public Int32Constant(int value) {
    //        _value = value;
    //    }

    //    /// <summary>
    //    /// 获取常量 0。
    //    /// </summary>
    //    public readonly static Int32Constant zero = new Int32Constant(0);

    //    /// <summary>
    //    /// 获取代表指定类型和值的表达式。
    //    /// </summary>
    //    /// <param name="type"></param>
    //    /// <param name="value"></param>
    //    /// <returns></returns>
    //    public static Constant from(int value) {
    //        return value == 0 ? zero : new Int32Constant(value);
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        int newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = +_value;
    //                break;
    //            case TokenType.sub:
    //                newValue = -_value;
    //                break;
    //            case TokenType.bitComplement:
    //                newValue = ~_value;
    //                break;
    //            default:
    //                throw new Unreachable();
    //        }

    //        if (this == zero) {
    //            return from(newValue);
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        int newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = _value + value.int32Value;
    //                break;
    //            case TokenType.sub:
    //                newValue = _value - value.int32Value;
    //                break;
    //            case TokenType.mul:
    //                newValue = _value * value.int32Value;
    //                break;
    //            case TokenType.div:
    //                newValue = _value / value.int32Value;
    //                break;
    //            case TokenType.mod:
    //                newValue = _value % value.int32Value;
    //                break;
    //            case TokenType.pow:
    //                newValue = (int)Math.Pow(_value, value.int32Value);
    //                break;
    //            case TokenType.bitAnd:
    //                newValue = _value & value.int32Value;
    //                break;
    //            case TokenType.bitOr:
    //                newValue = _value | value.int32Value;
    //                break;
    //            case TokenType.bitXor:
    //                newValue = _value ^ value.int32Value;
    //                break;
    //            case TokenType.bitShl:
    //                newValue = _value << value.int32Value;
    //                break;
    //            case TokenType.bitShr:
    //                newValue = _value >> value.int32Value;
    //                break;
    //            case TokenType.eq:
    //                return BoolConstant.from(_value == value.int32Value);
    //            case TokenType.ne:
    //                return BoolConstant.from(_value != value.int32Value);
    //            case TokenType.lt:
    //                return BoolConstant.from(_value < value.int32Value);
    //            case TokenType.lte:
    //                return BoolConstant.from(_value <= value.int32Value);
    //            case TokenType.gt:
    //                return BoolConstant.from(_value > value.int32Value);
    //            case TokenType.gte:
    //                return BoolConstant.from(_value >= value.int32Value);
    //            default:
    //                throw new Unreachable();
    //        }

    //        if (this == zero) {
    //            return from(newValue);
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        Int32Constant val = other as Int32Constant;
    //        return val != null && _value == val._value;
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return _value.GetHashCode();
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            return _value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            return (uint)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            return (long)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            return (ulong)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            return (float)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            return (double)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(_value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个 32 位无符整数常量。
    ///// </summary>
    //public sealed partial class UInt32Constant : Constant {

    //    /// <summary>
    //    /// 当前常量的值。
    //    /// </summary>
    //    uint _value;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_UInt32;
    //        }
    //    }

    //    public UInt32Constant(uint value) {
    //        _value = value;
    //    }

    //    /// <summary>
    //    /// 获取代表指定类型和值的表达式。
    //    /// </summary>
    //    /// <param name="type"></param>
    //    /// <param name="value"></param>
    //    /// <returns></returns>
    //    public static Constant from(uint value) {
    //        return new UInt32Constant(value);
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        uint newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = +_value;
    //                break;
    //            case TokenType.bitComplement:
    //                newValue = ~_value;
    //                break;
    //            default:
    //                throw new Unreachable();
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        uint newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = _value + value.uint32Value;
    //                break;
    //            case TokenType.sub:
    //                newValue = _value - value.uint32Value;
    //                break;
    //            case TokenType.mul:
    //                newValue = _value * value.uint32Value;
    //                break;
    //            case TokenType.div:
    //                newValue = _value / value.uint32Value;
    //                break;
    //            case TokenType.mod:
    //                newValue = _value % value.uint32Value;
    //                break;
    //            case TokenType.pow:
    //                newValue = (uint)Math.Pow(_value, value.uint32Value);
    //                break;
    //            case TokenType.bitAnd:
    //                newValue = _value & value.uint32Value;
    //                break;
    //            case TokenType.bitOr:
    //                newValue = _value | value.uint32Value;
    //                break;
    //            case TokenType.bitXor:
    //                newValue = _value ^ value.uint32Value;
    //                break;
    //            case TokenType.eq:
    //                return BoolConstant.from(_value == value.uint32Value);
    //            case TokenType.ne:
    //                return BoolConstant.from(_value != value.uint32Value);
    //            case TokenType.lt:
    //                return BoolConstant.from(_value < value.uint32Value);
    //            case TokenType.lte:
    //                return BoolConstant.from(_value <= value.uint32Value);
    //            case TokenType.gt:
    //                return BoolConstant.from(_value > value.uint32Value);
    //            case TokenType.gte:
    //                return BoolConstant.from(_value >= value.uint32Value);
    //            default:
    //                throw new Unreachable();
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        UInt32Constant val = other as UInt32Constant;
    //        return val != null && _value == val._value;
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return _value.GetHashCode();
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            return (int)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            return (uint)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            return (long)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            return (ulong)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            return (float)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            return (double)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(_value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个 64 位有符整数常量。
    ///// </summary>
    //public sealed partial class Int64Constant : Constant {

    //    /// <summary>
    //    /// 当前常量的值。
    //    /// </summary>
    //    long _value;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Int64;
    //        }
    //    }

    //    public Int64Constant(long value) {
    //        _value = value;
    //    }

    //    /// <summary>
    //    /// 获取代表指定类型和值的表达式。
    //    /// </summary>
    //    /// <param name="type"></param>
    //    /// <param name="value"></param>
    //    /// <returns></returns>
    //    public static Constant from(long value) {
    //        return new Int64Constant(value);
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        long newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = +_value;
    //                break;
    //            case TokenType.sub:
    //                newValue = -_value;
    //                break;
    //            case TokenType.bitComplement:
    //                newValue = ~_value;
    //                break;
    //            default:
    //                throw new Unreachable();
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        long newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = _value + value.int64Value;
    //                break;
    //            case TokenType.sub:
    //                newValue = _value - value.int64Value;
    //                break;
    //            case TokenType.mul:
    //                newValue = _value * value.int64Value;
    //                break;
    //            case TokenType.div:
    //                newValue = _value / value.int64Value;
    //                break;
    //            case TokenType.mod:
    //                newValue = _value % value.int64Value;
    //                break;
    //            case TokenType.pow:
    //                newValue = (long)Math.Pow(_value, value.int64Value);
    //                break;
    //            case TokenType.bitAnd:
    //                newValue = _value & value.int64Value;
    //                break;
    //            case TokenType.bitOr:
    //                newValue = _value | value.int64Value;
    //                break;
    //            case TokenType.bitXor:
    //                newValue = _value ^ value.int64Value;
    //                break;
    //            case TokenType.eq:
    //                return BoolConstant.from(_value == value.int64Value);
    //            case TokenType.ne:
    //                return BoolConstant.from(_value != value.int64Value);
    //            case TokenType.lt:
    //                return BoolConstant.from(_value < value.int64Value);
    //            case TokenType.lte:
    //                return BoolConstant.from(_value <= value.int64Value);
    //            case TokenType.gt:
    //                return BoolConstant.from(_value > value.int64Value);
    //            case TokenType.gte:
    //                return BoolConstant.from(_value >= value.int64Value);
    //            default:
    //                throw new Unreachable();
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        Int64Constant val = other as Int64Constant;
    //        return val != null && _value == val._value;
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return _value.GetHashCode();
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            return (int)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            return (uint)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            return (long)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            return (ulong)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            return (float)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            return (double)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(_value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个 64 位无符整数常量。
    ///// </summary>
    //public sealed partial class UInt64Constant : Constant {

    //    /// <summary>
    //    /// 当前常量的值。
    //    /// </summary>
    //    ulong _value;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_UInt64;
    //        }
    //    }

    //    public UInt64Constant(ulong value) {
    //        _value = value;
    //    }

    //    /// <summary>
    //    /// 获取代表指定类型和值的表达式。
    //    /// </summary>
    //    /// <param name="type"></param>
    //    /// <param name="value"></param>
    //    /// <returns></returns>
    //    public static Constant from(ulong value) {
    //        return new UInt64Constant(value);
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        ulong newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = +_value;
    //                break;
    //            case TokenType.bitComplement:
    //                newValue = ~_value;
    //                break;
    //            default:
    //                throw new Unreachable();
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        ulong newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = _value + value.uint64Value;
    //                break;
    //            case TokenType.sub:
    //                newValue = _value - value.uint64Value;
    //                break;
    //            case TokenType.mul:
    //                newValue = _value * value.uint64Value;
    //                break;
    //            case TokenType.div:
    //                newValue = _value / value.uint64Value;
    //                break;
    //            case TokenType.mod:
    //                newValue = _value % value.uint64Value;
    //                break;
    //            case TokenType.pow:
    //                newValue = (ulong)Math.Pow(_value, value.uint64Value);
    //                break;
    //            case TokenType.bitAnd:
    //                newValue = _value & value.uint64Value;
    //                break;
    //            case TokenType.bitOr:
    //                newValue = _value | value.uint64Value;
    //                break;
    //            case TokenType.bitXor:
    //                newValue = _value ^ value.uint64Value;
    //                break;
    //            case TokenType.eq:
    //                return BoolConstant.from(_value == value.uint64Value);
    //            case TokenType.ne:
    //                return BoolConstant.from(_value != value.uint64Value);
    //            case TokenType.lt:
    //                return BoolConstant.from(_value < value.uint64Value);
    //            case TokenType.lte:
    //                return BoolConstant.from(_value <= value.uint64Value);
    //            case TokenType.gt:
    //                return BoolConstant.from(_value > value.uint64Value);
    //            case TokenType.gte:
    //                return BoolConstant.from(_value >= value.uint64Value);
    //            default:
    //                throw new Unreachable();
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        UInt64Constant val = other as UInt64Constant;
    //        return val != null && _value == val._value;
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return _value.GetHashCode();
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            return (int)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            return (uint)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            return (long)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            return (ulong)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            return (float)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            return (double)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(_value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个 32 位浮点数常量。
    ///// </summary>
    //public sealed partial class Float32Constant : Constant {

    //    /// <summary>
    //    /// 当前常量的值。
    //    /// </summary>
    //    float _value;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Float32;
    //        }
    //    }

    //    public Float32Constant(float value) {
    //        _value = value;
    //    }

    //    /// <summary>
    //    /// 获取代表指定类型和值的表达式。
    //    /// </summary>
    //    /// <param name="type"></param>
    //    /// <param name="value"></param>
    //    /// <returns></returns>
    //    public static Constant from(float value) {
    //        return new Float32Constant(value);
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        float newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = +_value;
    //                break;
    //            case TokenType.sub:
    //                newValue = -_value;
    //                break;
    //            default:
    //                throw new Unreachable();
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        float newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = _value + value.float32Value;
    //                break;
    //            case TokenType.sub:
    //                newValue = _value - value.float32Value;
    //                break;
    //            case TokenType.mul:
    //                newValue = _value * value.float32Value;
    //                break;
    //            case TokenType.div:
    //                newValue = _value / value.float32Value;
    //                break;
    //            case TokenType.mod:
    //                newValue = _value % value.float32Value;
    //                break;
    //            case TokenType.pow:
    //                newValue = (float)Math.Pow(_value, value.float32Value);
    //                break;
    //            case TokenType.eq:
    //                return BoolConstant.from(_value == value.float32Value);
    //            case TokenType.ne:
    //                return BoolConstant.from(_value != value.float32Value);
    //            case TokenType.lt:
    //                return BoolConstant.from(_value < value.float32Value);
    //            case TokenType.lte:
    //                return BoolConstant.from(_value <= value.float32Value);
    //            case TokenType.gt:
    //                return BoolConstant.from(_value > value.float32Value);
    //            case TokenType.gte:
    //                return BoolConstant.from(_value >= value.float32Value);
    //            default:
    //                throw new Unreachable();
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        Float32Constant val = other as Float32Constant;
    //        return val != null && _value == val._value;
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return _value.GetHashCode();
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            return (int)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            return (uint)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            return (long)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            return (ulong)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            return (float)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            return (double)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(_value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个 64 位浮点数常量。
    ///// </summary>
    //public sealed partial class Float64Constant : Constant {

    //    /// <summary>
    //    /// 当前常量的值。
    //    /// </summary>
    //    double _value;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Float64;
    //        }
    //    }

    //    public Float64Constant(double value) {
    //        _value = value;
    //    }

    //    /// <summary>
    //    /// 获取代表指定类型和值的表达式。
    //    /// </summary>
    //    /// <param name="type"></param>
    //    /// <param name="value"></param>
    //    /// <returns></returns>
    //    public static Constant from(double value) {
    //        return new Float64Constant(value);
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        double newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = +_value;
    //                break;
    //            case TokenType.sub:
    //                newValue = -_value;
    //                break;
    //            default:
    //                throw new Unreachable();
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        double newValue;
    //        switch (@operator) {
    //            case TokenType.add:
    //                newValue = _value + value.float64Value;
    //                break;
    //            case TokenType.sub:
    //                newValue = _value - value.float64Value;
    //                break;
    //            case TokenType.mul:
    //                newValue = _value * value.float64Value;
    //                break;
    //            case TokenType.div:
    //                newValue = _value / value.float64Value;
    //                break;
    //            case TokenType.mod:
    //                newValue = _value % value.float64Value;
    //                break;
    //            case TokenType.pow:
    //                newValue = (double)Math.Pow(_value, value.float64Value);
    //                break;
    //            case TokenType.eq:
    //                return BoolConstant.from(_value == value.float64Value);
    //            case TokenType.ne:
    //                return BoolConstant.from(_value != value.float64Value);
    //            case TokenType.lt:
    //                return BoolConstant.from(_value < value.float64Value);
    //            case TokenType.lte:
    //                return BoolConstant.from(_value <= value.float64Value);
    //            case TokenType.gt:
    //                return BoolConstant.from(_value > value.float64Value);
    //            case TokenType.gte:
    //                return BoolConstant.from(_value >= value.float64Value);
    //            default:
    //                throw new Unreachable();
    //        }

    //        _value = newValue;
    //        return this;
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        Float64Constant val = other as Float64Constant;
    //        return val != null && _value == val._value;
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return _value.GetHashCode();
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            return (int)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            return (uint)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            return (long)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            return (ulong)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            return (float)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            return (double)_value;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(_value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个字符串常量。
    ///// </summary>
    //public sealed partial class StringConstant : Constant {

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_String;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    string _value;

    //    public StringConstant(string value) {
    //        _value = value;
    //    }

    //    /// <summary>
    //    /// 获取当前 null 常量的实例。
    //    /// </summary>
    //    public static readonly StringConstant @null = new StringConstant(null);

    //    /// <summary>
    //    /// 获取当前空字符串常量的实例。
    //    /// </summary>
    //    public new static readonly StringConstant @empty = new StringConstant(String.Empty);

    //    /// <summary>
    //    /// 获取代表指定类型和值的表达式。
    //    /// </summary>
    //    /// <param name="value"></param>
    //    /// <returns></returns>
    //    public static Constant from(string value) {
    //        switch (value) {
    //            case null:
    //                return @null;
    //            case "":
    //                return @empty;
    //            default:
    //                return new StringConstant(value);
    //        }
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        throw new Unreachable();
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        throw new Unreachable();
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        StringConstant val = other as StringConstant;
    //        return val != null && _value == val._value;
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return _value.GetHashCode();
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public string stringValue {
    //        get {
    //            return _value;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(_value);
    //    }

    //}

    ///// <summary>
    ///// 表示一个枚举值常量。
    ///// </summary>
    //public sealed partial class EnumConstant : Constant {

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return _value.parentType;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    FieldReference _value;

    //    public EnumConstant(FieldReference value) {
    //        _value = value;
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        throw new Unreachable();
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        throw new Unreachable();
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        EnumConstant val = other as EnumConstant;
    //        return val != null && ((Constant)_value.initialValue).Equals(val._value.initialValue);
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return _value.GetHashCode();
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            return ((Constant)_value.initialValue).int32Value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            return ((Constant)_value.initialValue).uint32Value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            return ((Constant)_value.initialValue).int64Value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            return ((Constant)_value.initialValue).uint64Value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            return ((Constant)_value.initialValue).float32Value;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            return ((Constant)_value.initialValue).float64Value;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(_value.fullName);
    //    }

    //}

    ///// <summary>
    ///// 表示一个字符串常量。
    ///// </summary>
    //public sealed partial class NullConstant : Constant {

    //    TypeReference _type;

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return _type;
    //        }
    //    }

    //    public NullConstant(TypeReference type) {
    //        _type = type;
    //    }

    //    /// <summary>
    //    /// 获取当前 null 常量的实例。
    //    /// </summary>
    //    public static readonly NullConstant @default = new NullConstant(PredefinedTypes.@void);

    //    /// <summary>
    //    /// 获取指定类型的空类型。
    //    /// </summary>
    //    /// <param name="type"></param>
    //    /// <returns></returns>
    //    public static Constant from(TypeReference type) {
    //        switch (type.primitiveType) {
    //            case PrimitiveType.none:
    //            case PrimitiveType.ptr:
    //                return new NullConstant(type);
    //            case PrimitiveType.@bool:
    //                return BoolConstant.@false;
    //            case PrimitiveType.@byte:
    //            case PrimitiveType.@char:
    //            case PrimitiveType.int16:
    //            case PrimitiveType.uint16:
    //                return new SmallIntConstant(type, 0);
    //            case PrimitiveType.int32:
    //                return Int32Constant.zero;
    //            case PrimitiveType.uint32:
    //                return UInt32Constant.from(0U);
    //            case PrimitiveType.int64:
    //                return Int64Constant.from(0L);
    //            case PrimitiveType.uint64:
    //                return UInt64Constant.from(0UL);
    //            case PrimitiveType.float32:
    //                return Float32Constant.from(0F);
    //            case PrimitiveType.float64:
    //                return Float64Constant.from(0D);
    //            default:
    //                throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        throw new Unreachable();
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        throw new Unreachable();
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        return this == other;
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return 0;
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            return 0;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            return 0;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            return 0;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            return 0;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            return 0;
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            return 0;
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write("null");
    //    }

    //}

    ///// <summary>
    ///// 表示一个 true 常量。
    ///// </summary>
    //public sealed partial class BoolConstant : Constant {

    //    /// <summary>
    //    /// 获取当前表达式解析后的返回值类型。
    //    /// </summary>
    //    public override TypeReference resolvedType {
    //        get {
    //            return PredefinedTypes.System_Bool;
    //        }
    //    }

    //    private BoolConstant() {

    //    }

    //    /// <summary>
    //    /// 获取当前 true 常量的实例。
    //    /// </summary>
    //    public static readonly BoolConstant @true = new BoolConstant();

    //    /// <summary>
    //    /// 获取当前 false 常量的实例。
    //    /// </summary>
    //    public static readonly BoolConstant @false = new BoolConstant();

    //    /// <summary>
    //    /// 获取代表指定类型和值的表达式。
    //    /// </summary>
    //    /// <param name="value"></param>
    //    /// <returns></returns>
    //    public static Constant from(bool value) {
    //        return value ? @true : @false;
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的单目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator) {
    //        throw new Unreachable();
    //    }

    //    /// <summary>
    //    /// 对当前常数应用指定的双目运算符并返回计算结果。
    //    /// </summary>
    //    /// <param name="operator">要计算的运算符。</param>
    //    /// <param name="value">要计算的运算数。</param>
    //    /// <returns>返回计算后的常量。</returns>
    //    public override Constant calc(TokenType @operator, Constant value) {
    //        switch (@operator) {
    //            case TokenType.bitAnd:
    //                return this == value ? this : @false;
    //            case TokenType.bitOr:
    //                return this == value ? this : @true;
    //            case TokenType.eq:
    //                return from(this == value);
    //            case TokenType.ne:
    //            case TokenType.bitXor:
    //                return from(this != value);
    //            default:
    //                throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 判断当前常量和目标常量是否相等。
    //    /// </summary>
    //    /// <param name="other"></param>
    //    /// <returns></returns>
    //    public override bool Equals(object other) {
    //        return this == other;
    //    }

    //    /// <summary>
    //    /// 用作特定类型的哈希函数。
    //    /// </summary>
    //    /// <returns>当前对象的哈希代码。</returns>
    //    public override int GetHashCode() {
    //        return this == @true ? 1 : 0;
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override int int32Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override uint uint32Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override long int64Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override ulong uint64Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override float float32Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 获取当前常量的值。
    //    /// </summary>
    //    public override double float64Value {
    //        get {
    //            throw new Unreachable();
    //        }
    //    }

    //    /// <summary>
    //    /// 将当前节点写入指定的 <see cref="IndentedTextWriter" /> 对象。
    //    /// </summary>
    //    /// <param name="writer">写入的目标对象。</param>
    //    public override void write(IndentedTextWriter writer) {
    //        writer.Write(this == @true ? "true" : "false");
    //    }

    //}

    //#endregion

    #region DynamicExpression

    /// <summary>
    /// 表示一个已解析的代表从动态对象调用成员的表达式。
    /// </summary>
    public class ResolvedDynamicMemberCallExpression : ResolvedExpression {

        /// <summary>
        /// 获取调用的目标对象。
        /// </summary>
        public Expression target;

        /// <summary>
        /// 获取调用的属性名。
        /// </summary>
        public string memberName;

        /// <summary>
        /// 获取调用的泛型参数数。
        /// </summary>
        public int genericArguments;

    }

    #endregion

}
